



import bpy
from bpy.types import Operator
from 全局控制.Node.节点和插座基类.bl_UpdateNode import *
import 全局控制.Node.节点和插座基类.bl_节点基类 as 基类
import 全局控制.Node.插座.bl_插座基类 as 插件基类

from 全局控制.Node.节点数据类型 import bl_集合数据类型

import engine.initLIB.load_dll as engineLib
import ctypes





import pdb


class C_SN_Int容器(基类.C_SN_基类):
	bl_dname = 'bl_node_IntList'
	bl_label = 'IntList'
	
	m_Value = bpy.props.CollectionProperty(type=bl_集合数据类型.C_数组元素_i)
	def init(self, context):
		super(C_SN_Int容器, self).f_init(context)
		
		self.inputs.new('C_NodeSocket_ni', name='初始化序列')
		self.inputs.new('C_NodeSocket_ni', name='添加元素')
		self.inputs.new('C_NodeSocket_引用', name='删除元素')
		
		self.outputs.new('C_NodeSocket_ni', name='元素序列')

		#self.inputs['删除元素'].f_setData(-1)
		#self.inputs['初始化序列'].


	#def draw_buttons(self, context, layout):
	#	column = layout.column()
	def update(self):
		pass
		'''矩阵插座 = self.inputs['输入坐标']
		rut = 插件基类.f_连接到插座是否为正确类型(矩阵插座, 'C_NodeSocket_ni')
		if rut == -1 :
			self.color = (1.0 , 0.0, 0.0)
		else:
			self.color = (0.5 , 0.5, 0.5)'''
	def f_input插座Update(self, input插座, 上层Output=None):
		#print('int 容器 = ', input插座, 上层Output)
		if input插座 :
			if input插座.name == '初始化序列':
				self.outputs['元素序列'].f_setData(input插座.f_getData())
				#print('input插座.f_getData() = ', input插座, input插座.f_getData())
			elif input插座.name == '添加元素':
				objs = input插座.f_getData()
				#print(objs)
				self.outputs['元素序列'].f_addData(objs)
				#print('f_input插座Update.f_addData() = ', objs, self, 上层Output, self.outputs['元素序列'].f_getData())
			#elif input插座.name == '删除元素':
			#	self.m_删除ID = input插座.f_getData()
		#print('f_input插座Update C_SN_Int容器 = ', C_SN_Int容器, input插座)
		super(C_SN_Int容器, self).f_input插座Update(input插座, 上层Output)

	def f_update(self, 是否向下传递=False, input插座=None):
		#self.outputs['元素序列'].f_setData(self.inputs['初始化序列'].f_getData())
		print(' f_update int 容器 ')
		input插座 = self.inputs['删除元素']
		if input插座.is_linked :
			删除ID = input插座.f_getData()
			
			typeName = 删除ID.__class__.__name__
			if typeName == 'list' :
				self.outputs['元素序列'].f_pop多Data(删除ID)
			elif typeName == 'int' or typeName == 'float':
				if 删除ID == -1:
					self.outputs['元素序列'].f_clear()
					#print('删除ID - input插座.f_pop多Data() = ', 删除ID, self, self.outputs['元素序列'].f_getData())
				else:
					self.outputs['元素序列'].f_pop多Data([删除ID])

			#print('== 删除节点 == ', 删除ID, typeName, self.outputs['元素序列'].f_getData())

		super(C_SN_Int容器, self).f_update(是否向下传递, input插座)
		




class C_NODE_AddMenu_Int容器(bpy.types.Operator):
	bl_idname = 'node.global_node_int_container_add'
	bl_label = 'Int 数据容器'
	bl_options = {'REGISTER', 'UNDO'}
	
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_SN_Int容器', use_transform=True)
		return {'FINISHED'}




g_Int容器_取数据ID下标 = {}

class C_SN_Int容器_取元素(基类.C_SN_基类):
	bl_dname = 'bl_node_IntList'
	bl_label = '取 IntList 元素'
	
	#m_Value = bpy.props.IntProperty(default=1)
	def init(self, context):
		super(C_SN_Int容器_取元素, self).f_init(context)
		
		self.inputs.new('C_NodeSocket_ni', name='Int_List')
		self.inputs.new('C_NodeSocket_ni', name='Index')
		self.outputs.new('C_NodeSocket_i', name='元素')
		#self.inputs['初始化序列'].
		self.inputs['Int_List'].f_set功能状态(1)

		g_Int容器_取数据ID下标[self.id_data.name+self.name] = -1

	def f_input插座Update(self, input插座, 上层Output=None):
		if input插座 :
			if input插座.name == 'Index':
				ID = input插座.f_getData()
				g_Int容器_取数据ID下标[self.id_data.name+self.name] = ID
				
				
	def f_update(self, 是否向下传递=False, input插座=None):
		#坑 f_getData(ID) 有可能取到空列表的值
		ID = g_Int容器_取数据ID下标[self.id_data.name+self.name]
		if ID >= 0 :
			data = self.inputs['Int_List'].f_getData(ID)
			self.outputs['元素'].f_setData(data)

		super(C_SN_Int容器_取元素, self).f_update(是否向下传递, input插座)

class C_NODE_AddMenu_Int容器_取元素(bpy.types.Operator):
	bl_idname = 'node.global_node_int_container_get_element'
	bl_label = '取Int数据容器元素'
	bl_options = {'REGISTER', 'UNDO'}
	
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_SN_Int容器_取元素', use_transform=True)
		return {'FINISHED'}















def f_值更新到内部节点(self, context):
	engineLib.flexCAPI.f_node_传入BL数据(ctypes.c_wchar_p(self.id_data.name), ctypes.c_wchar_p(self.name), ctypes.py_object(int(self.m_Value)));
	
class C_Node_Int32值(基类.C_Node_基类):
	bl_dname = 'bl_node_Int32值'
	bl_label = 'Int32值'
	
	m_Value = bpy.props.IntProperty(default=0, update=f_值更新到内部节点)
	def init(self, context):
		super(C_Node_Int32值, self).f_init(context)
		self.outputs.new('C_Socket_I32', name='V')

		self.f_toCPP()

		
	def draw_buttons(self, context, layout):
		#row = layout.row()
		layout.prop(self, 'm_Value')
		
	def f_toCPP(self):
		engineLib.flexCAPI.f_创建Int32值节点(ctypes.c_wchar_p(self.id_data.name), ctypes.c_wchar_p(self.name));
		

class C_MENU_Add_Int32值(bpy.types.Operator):
	bl_idname = 'node.global_add_value_int'
	bl_label = 'Int32值'
	#bl_options = {'REGISTER', 'UNDO'}
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_Node_Int32值', use_transform=True)
		return {'FINISHED'}









classes = (
	C_SN_Int容器,
	C_NODE_AddMenu_Int容器,
	
	C_SN_Int容器_取元素,
	C_NODE_AddMenu_Int容器_取元素,



	C_Node_Int32值,
	C_MENU_Add_Int32值,


)




def register():
	for c in classes:
		bpy.utils.register_class(c)
		

def unregister():
	for c in classes:
		bpy.utils.unregister_class(c)

	

